\section{Introduction}

\subsection{Sujet officiel}

\noindent
\textbf{Encadrants} : Jérémie Albert, Serge Chaumette\\
\textbf{Mots-clés} : Android, Arduino, tablettes, réseaux mobiles ad hoc\\
\textbf{Matériels mis à disposition} : Tablettes Android, processeurs et \textit{shields} Arduino\\
\textbf{Équipe de recherche concernée} : Thème Muse de l’équipe LSR du LaBRI\\

La prolifération des systèmes embarqués et l’apparition de nouvelles
technologies autour des réseaux sans fil ont permis la conception
d’applications novatrices ciblant l’\textit{Internet des Choses}. Le
réseau (ad hoc) sous-jacent est uniquement formé par les liens mis en place deux à deux par les objets communicants. Le présent projet vise à fournir une plate-forme de gestion de ces matériels/réseaux. Il a deux objectifs : technique et didactique.\\

Le travail demandé a pour objet de permettre la prise en main de ces équipements et de fournir une plate-forme d’administration permettant de les gérer.\\

Il faudra en particulier réaliser les étapes suivantes :
\begin{itemize}
\item Installation et mise en oeuvre sur des tests des plates-formes Arduino et tablettes Android
\item Réalisation d’objets communicants à base de technologie Arduino
\item Mise en place de communications Arduino/tablette Android
\item Conception et mise en oeuvre d’une plate-forme d’administration d’équipements Arduino sur tablette Android\\
\end{itemize}

\subsection{Compréhension du sujet}

De nouvelles technologies et manières de penser doivent être créées pour exploiter au maximum le potentiel des nouveaux genres de terminaux mobiles (smartphones et PDAs), qui sont à la jonction au niveau de la puissance et des fonctionnalités entre l'ordinateur et le téléphone mobile.\\

Par exemple, là où auparavant était utilisé le modèle d'échanges dit
"par infrastructure" requérant un serveur centralisé auquel devaient se
connecter les clients, le modèle de réseau "ad hoc" a été créé, du latin
pour dire "formé dans un but précis". Ce modèle permet à deux terminaux
mobiles de se connecter l'un à l'autre, en évitant le modèle
client/serveur et sans avoir à passer par un serveur central.\\

Ce modèle vient évidemment avec ses avantages, comme son efficacité (les données passent directement à leur destinataire plutôt que de parcourir un trajet inutile), mais aussi ses défauts liés à ses spécificités.\\

Ces défauts sont donc à prendre en compte lors du développement et ainsi sont nécessaires :
\begin{itemize}
\item La gestion des contraintes matérielles des terminaux mobiles (bande-passante et puissance de calcul limitée, consommation d'énergie à limiter)
\item La gestion de la mobilité des clients (détection de nouveaux n\oe{}uds, connexions au réseau, perte de routes entre deux clients, disparition d'un n\oe{}ud du réseau)
\item La gestion du routage (pas d'adresses "fixes", transmission des données n\oe{}ud à n\oe{}ud pour arriver au destinataire final)
\item La gestion de la latence et des interférences / éventuelles pertes de données induites par l'environnement
\item La gestion des limites de visibilité entre clients (n\oe{}uds cachés, duplicatas d'adresses)
\item La gestion de la sécurité des données\\
\end{itemize}

Le projet de notre équipe vise à fournir une plate-forme d'administration capable de gérer ces problèmes quant à la communication entre entités mobiles, et nous travaillerons plus particulièrement sur des tablettes Android et des processeurs/\textit{shields} (extensions) Arduino.

\subsection{Matériel à disposition}

Nous avons reçus dans le cadre du projet le matériel suivant :
\begin{itemize}
\item{2 tablettes Huawei Ideo S7 (système d'exploitation Android)}
\item{3 Starter Kits Arduino (carte \textit{UNO})}
\item{1 Sparkfun Inventor Kit Arduino (carte \textit{DUEMILANOVE})}
\item{4 modules Wi-Fi (Wifly)}
\item{4 modules XBee / 4 Puces XBee (séparées, à combiner)}
\item{2 modules GSM (avec carte, adaptateur antenne et antenne séparée)}
\item{2 modules GPS}
\item{4 modules écrans}
\item{2 blocs d'alimentation secteur (sortie de 6V à 12V)}
\item{2 blocs d'alimentation externe avec piles fournies (sortie 9V)}
\end{itemize}

\subsection{\'Etude préalable de la technologie Arduino}

Arduino est une plate-forme technologique faite pour qu'un terminal puisse détecter d'autres entités et communiquer de manière accessible avec elles. Il s'agit aussi bien d'un environnement de développement et de programmation qu'une technologie matérielle, c'est à dire une carte électronique. Les spécifications aussi bien matérielles que logicielles d'Arduino sont open source.\\

\begin{figure}[!h]
\centering
\includegraphics[scale=0.9]{circuit}
\caption{Photo de la carte Arduino Duemilanove}
\end{figure}

Le logiciel de programmation des modules officiels Arduino a été codé en Java, et sert d'éditeur de code aussi bien que de compilateur. Il peut également transférer les mises à jour du firmware et les programmes vers la carte Arduino.\\

Le langage de programmation Arduino est une variante allégée du C/C++ notamment en raison des contraintes matérielles (gestion des entrées/sorties) et des bibliothèques associées.\\

La carte Arduino peut accepter des \textit{shields}, qui sont des extensions matérielles à entrer dans les ports appropriés et qui permettent d'étendre ses capacités, par exemple un \textit{shield} Ethernet ou un \textit{shield} Zigbee pour pouvoir utiliser les technologies associées.

\subsubsection{Communication}
Les cartes Arduino \textit{Uno} et \textit{Duemilanove} possèdent entre autre un micro-contrôleur ATMega328. L'environnement d'Arduino possède un terminal simplifié permettant un dialogue via le port série. Le dialogue permet l'envoi et la réception de données textuelles entre le PC et la carte Arduino.
C'est grâce à ce port série que l'on communique avec les différents modules disponibles (GSM, Xbee, \dots), avec des primitives minimales (\texttt{Serial.print()}, \texttt{Serial.read()}, \dots).

\subsubsection{Alimentation}
Les cartes peuvent être alimentées soit par USB, soit par une alimentation externe. Bien qu'elles peuvent admettre une alimentation externe allant de 6 à 20V, l'alimentation recommandée et optimale doit être comprise entre 7 et 12V.

\subsubsection{Mémoire}
Le chipset ATmega328 possède 32 KB (donc 0.5 KB pour le bootloader) de mémoire pour le code compilé et embarqué, 2 KB de SDRAM et 1 KB de mémoire EEPROM\footnote{Electrically-erasable programmable read-only memory : Un type de mémoire morte}.

\subsubsection{Entrées-Sorties}

Chacun des 14 pins numériques peut être utilisé comme une entrée ou une sortie à l'aide des fonctions \texttt{pinMode()}, \texttt{digitalWrite()}, et \texttt{digitalRead()}.

Certains pins ont des fonctions spéciales :
\begin{itemize}
\item {Port série : 0 (RX) et 1 (TX). Utilisés pour recevoir (RX) et transmettre (TX) des données directement à travers le port série}
\item {Interrupteurs externes : 2 et 3. Ces pins peuvent être configurés pour déclencher une interruption sur une faible valeur, un front montant/descendant ou un changement de valeur}
\item {Les pins : 3, 5, 6, 9, 10, et 11 fournissent une sortie 8-bit}
\item{Les pins : 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK) supportent une communication SPI\footnote{Serial Peripheral Interface : un bus série synchrone, maître/esclave, full duplex de communication entre le micro-contrôleur et ses périphériques}\\}
\end{itemize}

Les cartes ont 6 entrées analogiques, marquées A0 à A5. Chacune d'elle fournit 10 bits de résolution (i.e. 1024 valeurs différentes). Par défaut, leur champs de mesure va de 0V à 5V (valeurs modifiables). Elles possèdent aussi un bouton \texttt{Reset} utilisé pour réinitialiser le chipset et redémarrer le programme embarqué.\\

Toute la documentation est disponible sur le site officiel d'Arduino pour la partie matérielle\cite{ArdUno} et logicielle\cite{ArdLog}.

\subsection{Environnement de développement Arduino}

Arduino possède sa propre interface de développement que l'on peut télécharger sur le site officiel\cite{ArdOff}. La démarche d'installation n'est bien évidemment pas la même en fonction des OS et/ou versions utilisées.

\subsubsection{Linux Ubuntu}

\normalsize{\textbf{Version 10.10}}

Ubuntu 10.10 possède déjà la suite Arduino dans ses dépôts officiels. L'installation se fait donc simplement :

\shadowbox{
\begin{lstlisting}[breaklines=true, breakatwhitespace=true]
$ : sudo apt-get install arduino
$ : arduino&
\end{lstlisting}}
\newline

\normalsize{\textbf{Version 10.04}}

Pour Ubuntu 10.04, il faut rajouter Arduino dans le dépôt manuellement :

\shadowbox{
\begin{lstlisting}[breaklines=true, breakatwhitespace=true]
$ : sudo add-apt-repository ppa:arduino-ubuntu-team
$ : sudo apt-get update
$ : sudo apt-get install arduino
$ : arduino&
\end{lstlisting}}
\newline

\textbf{\large{Attention !}}\\
La version actuelle de l'EDI des dépôts est la v.18, et ne supporte pas
la carte UNO. Il faut donc télécharger la dernière version (version 22)
de l'EDI depuis le site officiel\cite{ArdArchL} en plus de l'installation du paquet, et utiliser le binaire de l'archive à la place de celui du dépôt.
De plus, le paquet "\texttt{brltty}\footnote{BRLTTY est un démon qui
fournit à Linux l'accès en mode texte au terminal pour une personne aveugle utilisant un affichage en braille}" semble (d'après le site officiel) rentrer en conflit avec les paquets Arduino.

Il convient donc de le désinstaller :\\

\shadowbox{
\begin{lstlisting}[breaklines=true, breakatwhitespace=true]
$ : sudo apt-get remove brltty
\end{lstlisting}}

\subsubsection{Windows Vista \& Seven}

Il faut télécharger l'archive directement sur le site officiel\cite{ArdArchW}, la dézipper, puis lancer "arduino.exe" pour lancer l'EDI. L'installation du périphérique USB est automatique pour la carte DUEMILANOVE dès le branchement. Il faut par contre mettre à jour le driver de la carte UNO, depuis le gestionnaire de périphériques (le fichier driver \textit{ArduinoUNO.inf} se trouvant dans le dossier \textit{Drivers} de l'archive).\\

Liens qui nous ont été utiles :
\begin{itemize}
\item \url{http://www.arduino.cc/playground/Learning/Linux}
\item \url{http://arduino.cc/en/Guide/Windows}
\end{itemize}

\subsection{Environnement de développement Android}

Android est un système d'exploitation pour terminaux mobiles. Son environnement de développement permet de déployer des applications adaptées à ses spécificités, écrites dans le langage de programmation Java. Pour écrire ce code Java, nous avons utilisés l'environnement de développement intégré Eclipse.

\subimport{}{annexe_dev_android}
